home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Moscow ML 1.31 / source code / mosml / src / test / result.ok next >
Encoding:
Text File  |  1996-07-03  |  14.1 KB  |  388 lines  |  [TEXT/R*ch]
  1. Moscow ML version 1.31 (15 October 1995)
  2. Enter `quit();' to quit.
  3. [opening file "test.sml"]
  4. [opening file "test1.sml"]
  5. > val it = 1 : int
  6. > val it = 5 : int
  7. > val it = 100 : int
  8. > val fact = fn : int -> int
  9. > val it = 24 : int
  10. > val append2 = fn : 'a list * 'a list -> 'a list
  11. > val it = [1, 2, 3, 4, 5, 6] : int list
  12. > val append = fn : 'a list -> ('a list -> 'a list)
  13. > val it = [1, 2, 3, 4, 5, 6] : int list
  14. > val reverse = fn : 'a list -> 'a list
  15. > val it = [4, 3, 2, 1] : int list
  16. > val it = [false, true] : bool list
  17. > val @ = fn : 'a list * 'a list -> 'a list
  18. > infixr 5 @
  19. > val it = [1, 2, 3, 4, 5, 6] : int list
  20. [closing file "test1.sml"]
  21. > val it = () : unit
  22. [opening file "test2.sml"]
  23. > val fact = fn : int -> int
  24. > val it = 24 : int
  25. > val append2 = fn : 'a list * 'a list -> 'a list
  26. > val it = [1, 2, 3, 4, 5, 6] : int list
  27. > val append = fn : 'a list -> 'a list -> 'a list
  28. > val it = [1, 2, 3, 4, 5, 6] : int list
  29. > val reverse = fn : 'a list -> 'a list
  30. > val it = [4, 3, 2, 1] : int list
  31. > val it = [false, true] : bool list
  32. > val @ = fn : 'a list * 'a list -> 'a list
  33. > infixr 5 @
  34. > val it = [1, 2, 3, 4, 5, 6] : int list
  35. [closing file "test2.sml"]
  36. > val it = () : unit
  37. [opening file "test3.sml"]
  38. > datatype 'a Tree
  39.   con Lf = Lf : 'a Tree
  40.   con Br = fn : 'a * 'a Tree * 'a Tree -> 'a Tree
  41. > val t1 = Br(2, Br(1, Lf, Lf), Br(3, Lf, Lf)) : int Tree
  42. > val foldTree = fn : ('a -> ('b -> ('b -> 'b))) -> 'b -> 'a Tree -> 'b
  43. > val revBranch = fn : 'a -> 'a Tree -> 'a Tree -> 'a Tree
  44. > val reflect = fn : 'a Tree -> 'a Tree
  45. > val refl_t1 = Br(2, Br(3, Lf, Lf), Br(1, Lf, Lf)) : int Tree
  46. [closing file "test3.sml"]
  47. > val it = () : unit
  48. [opening file "test4.sml"]
  49. > val map = fn : ('a -> 'b) -> 'a list -> 'b list
  50. > val it = [2, 3, 4] : int list
  51. > infix 5 ++
  52. > val ++ = fn : 'a list * 'a list -> 'a list
  53. > val it = [1, 2, 3, 4, 5, 6] : int list
  54. > val reverse = fn : 'a list -> 'a list
  55. > val it = [4, 3, 2, 1] : int list
  56. > val it = [false, true] : bool list
  57. > infix 3 o
  58. > val o = fn : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b
  59. > val I = fn : 'a list -> 'a list
  60. > val it = [1, 2, 3] : int list
  61. > val zl = [(1, true), (2, false), (3, true)] : (int * bool) list
  62. > val fst = fn : 'a * 'b -> 'a
  63. > val snd = fn : 'a * 'b -> 'b
  64. > val it = [1, 2, 3] : int list
  65. > val split = fn : ('a * 'b) list -> 'a list * 'b list
  66. > val it = ([1, 2, 3], [true, false, true]) : int list * bool list
  67. > val member = fn : ''a -> ''a list -> bool
  68. > val it = true : bool
  69. > val it = false : bool
  70. [closing file "test4.sml"]
  71. > val it = () : unit
  72. [opening file "test5.sml"]
  73. > val it = [7] : int list
  74. > val Id = fn : '_a -> '_a
  75. > val Id' = fn : '_a -> '_a
  76. > val reverse = fn : '_a list -> '_a list
  77. > val it = [3, 2, 1] : int list
  78. > val it = [false, true] : bool list
  79. > val f = fn : int ref -> int ref * int
  80. > val it = (ref 666, 99) : int ref * int
  81. > val it = 8 : int
  82. [closing file "test5.sml"]
  83. > val it = () : unit
  84. [opening file "test6.sml"]
  85. > exn E = E : exn
  86. > val f = fn : unit -> 'a
  87. > val it = "OK" : string
  88. > val elist = [E, Size] : exn list
  89. > exn E' = E' : exn
  90. > val it = "OK" : string
  91. > val it = "OK" : string
  92. > exn G = fn : int -> exn
  93. > val it = "OK" : string
  94. [closing file "test6.sml"]
  95. > val it = () : unit
  96. [opening file "test7.sml"]
  97. > abstype 'a Stack
  98.   type 'a StackTop = 'a * 'a Stack
  99.   exn EmptyStack = EmptyStack : exn
  100.   val empty = <Stack> : 'a Stack
  101.   val top = fn : 'a Stack -> 'a
  102.   val push = fn : 'a -> 'a Stack -> 'a Stack
  103.   val pop = fn : 'a Stack -> 'a Stack
  104. > val st1 = <Stack> : int Stack
  105. > val top1 = 3 : int
  106. > val rest1 = <Stack> : int Stack
  107. [closing file "test7.sml"]
  108. > val it = () : unit
  109. [opening file "test8.sml"]
  110. > datatype 'a arex
  111.   type 'a binary = 'a arex * 'a arex
  112.   type 'a unary = 'a arex
  113.   con ADD = fn : 'a arex * 'a arex -> 'a arex
  114.   con SUB = fn : 'a arex * 'a arex -> 'a arex
  115.   con MINUS = fn : 'a arex -> 'a arex
  116.   con TIP = fn : 'a -> 'a arex
  117. > val a1 = MINUS(ADD(TIP 1, SUB(TIP 2, TIP 5))) : int arex
  118. [closing file "test8.sml"]
  119. > val it = () : unit
  120. [opening file "test9.sml"]
  121. > type person = {age : int, name : string}
  122. > val p1 = {age = 99, name = "Peter"} : {age : int, name : string}
  123. > val name1 = "Peter" : string
  124.   val age1 = 99 : int
  125. > val nameOfPerson = fn : {age : 'a, name : 'b} -> 'b
  126. > val name1 = "Peter" : string
  127. > val name = "Peter" : string
  128.   val age = 99 : int
  129. > val name = "Peter" : string
  130. > val name = "Peter" : string
  131.   val name1 = "Peter" : string
  132. > val f = fn : {age : int, name : string} -> string
  133. > val name1 = "Peter" : string
  134. > val age1 = 99 : int
  135. > val f = fn : {lab : int} -> int
  136. > val it =
  137.     (fn, true)
  138.     : ({l1 : ''a, l2 : int} -> {l1 : ''a, l3 : string} -> bool) * bool
  139. > val it =
  140.     (fn, fn, fn)
  141.     : ({l1 : 'a, l2 : ''b} -> 'a) * ({l1 : 'c, l2 : 'd} -> 'c * 'd) *
  142.       ({l1 : ''e, l2 : ''f} -> bool * ''e * (''e * ''f))
  143. [closing file "test9.sml"]
  144. > val it = () : unit
  145. [opening file "testa.sml"]
  146. > val even = fn : int -> bool
  147.   val odd = fn : int -> bool
  148. > val it = true : bool
  149. > val it = false : bool
  150. > datatype 'a X
  151.   con X = fn : string -> 'a X
  152. > val stripX = fn : 'a X -> string
  153. > val it = "OK" : string
  154. > val stripX666 = fn : 'a X -> 'a X
  155. > val it = X "000" : 'a X
  156. > val it = X "OK" : 'a X
  157. > datatype XXX
  158.   con A = fn : int * int -> XXX
  159.   con B = fn : int * int -> XXX
  160. > val a12 = A(1, 2) : XXX
  161.   val b12 = B(1, 2) : XXX
  162. > val strip = fn : XXX -> int * int
  163. > val it = false : bool
  164. > val it = true : bool
  165. [closing file "testa.sml"]
  166. > val it = () : unit
  167. [opening file "testb.sml"]
  168. File "testb.sml", line 3, characters 9-12:
  169. ! (let val nil = [1,2] and _ = raise Io "WRONG" in "DEAD" end)
  170. !          ^^^
  171. ! Warning: pattern matching is not exhaustive
  172.  
  173. > val it = "OK" : string
  174. File "testb.sml", line 5, characters 2-17:
  175. ! ((fn 0 => "WRONG") 1)
  176. !   ^^^^^^^^^^^^^^^
  177. ! Warning: pattern matching is not exhaustive
  178.  
  179. > val it = "OK" : string
  180. > val it = ["OK"] : string list
  181. > val it = ("OK", "OK") : string * string
  182. > val it = {aaa = "OK", bbb = "OK"} : {aaa : string, bbb : string}
  183. > val pr = fn : string -> string
  184. > val x7 =
  185.     fn
  186.     : 'a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g ->
  187.       'a * 'b * 'c * 'd * 'e * 'f * 'g
  188. 246> val it =
  189.     ("1", "2", "3", "4", "5", "6", "7")
  190.     : string * string * string * string * string * string * string
  191. > datatype ('a, 'b) AB
  192.   con NILab = NILab : ('a, 'b) AB
  193.   con CONSab = fn : {a : 'a, b : 'b} -> ('a, 'b) AB
  194. ab> val it = CONSab{a = "a", b = "b"} : (string, string) AB
  195. ba> val it = CONSab{a = "a", b = "b"} : (string, string) AB
  196. > val f = fn : 'a -> 'a
  197. > val f = fn : int -> int
  198. > val it = "OK" : string
  199. [closing file "testb.sml"]
  200. > val it = () : unit
  201. [opening file "testc.sml"]
  202. > datatype xxx
  203.   con P = P : xxx
  204.   con Q = fn : {key : (xxx ref * xxx ref) list} -> xxx
  205. > val z = ref P : xxx ref
  206. > val it = () : unit
  207. > val it =
  208.     ref(Q{key =
  209.             [(ref(Q{key =
  210.                       [(ref(Q{key =
  211.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  212.                                   ref(Q{key = [(#, #), (#, #)]})),
  213.                                  (ref(Q{key = [(#, #), (#, #)]}),
  214.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  215.                         ref(Q{key =
  216.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  217.                                   ref(Q{key = [(#, #), (#, #)]})),
  218.                                  (ref(Q{key = [(#, #), (#, #)]}),
  219.                                   ref(Q{key = [(#, #), (#, #)]}))]})),
  220.                        (ref(Q{key =
  221.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  222.                                   ref(Q{key = [(#, #), (#, #)]})),
  223.                                  (ref(Q{key = [(#, #), (#, #)]}),
  224.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  225.                         ref(Q{key =
  226.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  227.                                   ref(Q{key = [(#, #), (#, #)]})),
  228.                                  (ref(Q{key = [(#, #), (#, #)]}),
  229.                                   ref(Q{key = [(#, #), (#, #)]}))]}))]}),
  230.               ref(Q{key =
  231.                       [(ref(Q{key =
  232.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  233.                                   ref(Q{key = [(#, #), (#, #)]})),
  234.                                  (ref(Q{key = [(#, #), (#, #)]}),
  235.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  236.                         ref(Q{key =
  237.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  238.                                   ref(Q{key = [(#, #), (#, #)]})),
  239.                                  (ref(Q{key = [(#, #), (#, #)]}),
  240.                                   ref(Q{key = [(#, #), (#, #)]}))]})),
  241.                        (ref(Q{key =
  242.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  243.                                   ref(Q{key = [(#, #), (#, #)]})),
  244.                                  (ref(Q{key = [(#, #), (#, #)]}),
  245.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  246.                         ref(Q{key =
  247.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  248.                                   ref(Q{key = [(#, #), (#, #)]})),
  249.                                  (ref(Q{key = [(#, #), (#, #)]}),
  250.                                   ref(Q{key = [(#, #), (#, #)]}))]}))]})),
  251.              (ref(Q{key =
  252.                       [(ref(Q{key =
  253.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  254.                                   ref(Q{key = [(#, #), (#, #)]})),
  255.                                  (ref(Q{key = [(#, #), (#, #)]}),
  256.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  257.                         ref(Q{key =
  258.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  259.                                   ref(Q{key = [(#, #), (#, #)]})),
  260.                                  (ref(Q{key = [(#, #), (#, #)]}),
  261.                                   ref(Q{key = [(#, #), (#, #)]}))]})),
  262.                        (ref(Q{key =
  263.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  264.                                   ref(Q{key = [(#, #), (#, #)]})),
  265.                                  (ref(Q{key = [(#, #), (#, #)]}),
  266.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  267.                         ref(Q{key =
  268.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  269.                                   ref(Q{key = [(#, #), (#, #)]})),
  270.                                  (ref(Q{key = [(#, #), (#, #)]}),
  271.                                   ref(Q{key = [(#, #), (#, #)]}))]}))]}),
  272.               ref(Q{key =
  273.                       [(ref(Q{key =
  274.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  275.                                   ref(Q{key = [(#, #), (#, #)]})),
  276.                                  (ref(Q{key = [(#, #), (#, #)]}),
  277.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  278.                         ref(Q{key =
  279.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  280.                                   ref(Q{key = [(#, #), (#, #)]})),
  281.                                  (ref(Q{key = [(#, #), (#, #)]}),
  282.                                   ref(Q{key = [(#, #), (#, #)]}))]})),
  283.                        (ref(Q{key =
  284.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  285.                                   ref(Q{key = [(#, #), (#, #)]})),
  286.                                  (ref(Q{key = [(#, #), (#, #)]}),
  287.                                   ref(Q{key = [(#, #), (#, #)]}))]}),
  288.                         ref(Q{key =
  289.                                 [(ref(Q{key = [(#, #), (#, #)]}),
  290.                                   ref(Q{key = [(#, #), (#, #)]})),
  291.                                  (ref(Q{key = [(#, #), (#, #)]}),
  292.                                   ref(Q{key = [(#, #), (#, #)]}))]}))]}))]})
  293.     : xxx ref
  294. [closing file "testc.sml"]
  295. > val it = () : unit
  296. [opening file "testd.sml"]
  297. > val maxint = 1073741823 : int
  298. > val minint = ~1073741824 : int
  299. > infix 0 seq
  300.   val seq = fn : 'a * 'b -> 'b
  301. > val it = "OK" : string
  302. > val it = "OK" : string
  303. > val it = "OK" : string
  304. > val it = "OK" : string
  305. > val sum = fn : int * int -> int
  306. > val diff = fn : int * int -> int
  307. > val it = "OK" : string
  308. > val it = "OK" : string
  309. > val it = "OK" : string
  310. > val prod = fn : int * int -> int
  311. > val it = "OK" : string
  312. > val checkDivMod = fn : int -> int -> string
  313. 23 10   > val it = "OK" : string
  314. ~23 10   > val it = "OK" : string
  315. 23 ~10   > val it = "OK" : string
  316. ~23 ~10   > val it = "OK" : string
  317. 100 10   > val it = "OK" : string
  318. ~100 10   > val it = "OK" : string
  319. 100 ~10   > val it = "OK" : string
  320. ~100 ~10   > val it = "OK" : string
  321. 100 1   > val it = "OK" : string
  322. 100 ~1   > val it = "OK" : string
  323. 0 1   > val it = "OK" : string
  324. 0 ~1   > val it = "OK" : string
  325. > val it = "OK" : string
  326. > val it = "OK" : string
  327. > val it = "OK" : string
  328. > val maxri = 1073741823.0 : real
  329. > val minri = ~1073741824.0 : real
  330. > val it = "OK" : string
  331. > val it = "OK" : string
  332. > val it = "OK" : string
  333. > val it = "OK" : string
  334. > val it = "OK" : string
  335. > val it = "OK" : string
  336. > val it = "OK" : string
  337. > val it = "OK" : string
  338. > val it = "OK" : string
  339. > val it = "OK" : string
  340. [closing file "testd.sml"]
  341. > val it = () : unit
  342. [opening file "teste.sml"]
  343. > val MAXDOUBLE = 8.98846567431E307 : real
  344. > val MINDOUBLE = 4.94065645841E~324 : real
  345.   val pi = 3.14159265359 : real
  346. > val eps = 1E~15 : real
  347. > infix 0 seq
  348.   val seq = fn : 'a * 'b -> 'b
  349. > val check1 = fn : ('a -> real) * 'a * real -> string
  350. > val it = "OK" : string
  351. > val it = "OK" : string
  352. > val it = "OK" : string
  353. > val it = "OK" : string
  354. > val it = "OK" : string
  355. > val it = "OK" : string
  356. > val it = "OK" : string
  357. > val it = "OK" : string
  358. > val it = "OK" : string
  359. > val it = "OK" : string
  360. > val it = "OK" : string
  361. > val it = "OK" : string
  362. > val it = "OK" : string
  363. > val it = "OK" : string
  364. > val it = "OK" : string
  365. > val check2 = fn : ('a * 'b -> real) * 'a * 'b * real -> string
  366. > val it = "OK" : string
  367. > val it = "OK" : string
  368. > val it = "OK" : string
  369. > val it = "OK" : string
  370. > val it = "OK" : string
  371. > val it = "OK" : string
  372. > val it = "OK" : string
  373. > val it = "OK" : string
  374. > val it = "OK" : string
  375. > val it = "OK" : string
  376. > val it = "OK" : string
  377. > val it = "OK" : string
  378. > val it = "OK" : string
  379. > val it = "OK" : string
  380. > val it = "OK" : string
  381. > val maxexp = 709.089565712 : real
  382. > val it = "OK" : string
  383. > val it = "OK" : string
  384. > val it = "OK" : string
  385. > val f = fn : real -> real
  386. [closing file "teste.sml"]
  387. > val it = () : unit
  388.